namespace UnrealBuildTool.Rules 
{ 
    public class TestModuleEd : ModuleRules 
    { 
        public TestModuleEd(ReadOnlyTargetRules Target) : base(Target) 
        { 
            PublicIncludePaths.AddRange( 
                new string[] { 
                    "TestModuleEd", 
                    // ... add public include paths required here ... 
                } 
                ); 
            PrivateIncludePaths.AddRange( 
                new string[] { 
                    "TestModuleEd", 
                    // ... add other private include paths required here ... 
                } 
                ); 
            PublicDependencyModuleNames.AddRange( 
                new string[] 
                { 
                    "Core", 
                    "CoreUObject", 
                    "Engine", 
                    // ... add other public dependencies that you statically link with here ... 
                } 
                ); 
            PrivateDependencyModuleNames.AddRange( 
                new string[] 
                { 
                    // ... add private dependencies that you statically link with here ... 
                } 
                ); 
            DynamicallyLoadedModuleNames.AddRange( 
                new string[] 
                { 
                    // ... add any modules that your module loads dynamically here ... 
                } 
                ); 
        } 
    } 
} 

#pragma once 
#include "CoreMinimal.h" 
#include "Modules/ModuleInterface.h" 
#include "Modules/ModuleManager.h" 
/** 
 * The public interface to this module 
 */ 
class ITestModuleEd : public IModuleInterface 
{ 
public: 
    /** 
     * Singleton-like access to this module's interface.  This is just for convenience 
     * Beware of calling this during the shutdown phase, though.  Your module might have been unloaded already. 
     * 
     * @return Returns singleton instance, loading the module on demand if needed 
     */ 
    static inline ITestModuleEd& Get() 
    { 
        return FModuleManager::LoadModuleChecked< ITestModuleEd >( "TestModuleEd" ); 
    } 
    /** 
     * Checks to see if this module is loaded and ready.  It is only valid to call Get() if IsAvailable() returns true. 
     * 
     * @return True if the module is loaded and ready to use 
     */ 
    static inline bool IsAvailable() 
    { 
        return FModuleManager::Get().IsModuleLoaded( "TestModuleEd" ); 
    } 
}; 

#include "TestModuleEd/TestModuleEd.h" 
class FTestModuleEd : public ITestModuleEd 
{ 
    /** IModuleInterface implementation */ 
    virtual void StartupModule() override; 
    virtual void ShutdownModule() override; 
}; 
IMPLEMENT_MODULE( FTestModuleEd, TestModuleEd ) 
void FTestModuleEd::StartupModule() 
{ 
    // This code will execute after your module is loaded into memory (but after global variables are initialized, of course.) 
} 
void FTestModuleEd::ShutdownModule() 
{ 
    // This function may be called during shutdown to clean up your module.  For modules that support dynamic reloading, 
    // we call this function before unloading the module. 
} 

{
    "FileVersion": 3,
    "EngineAssociation": "4.22",
    "Category": "",
    "Description": "",
    "Modules": [
        {
            "Name": "MyProject",
            "Type": "Runtime",
            "LoadingPhase": "Default",
            "AdditionalDependencies": [
                "Engine"
            ]
        }
## ここから追加↓、（カンマに注意）
        ,{
            "Name": "TestModuleEd",
            "Type": "Editor",
            "LoadingPhase": "PostEngineInit"
        }
## ここまで↑
    ],
    "Plugins": [
        {
            "Name": "EditorTests",
            "Enabled": true
        },
    ]
}

using UnrealBuildTool;

public class MyProject : ModuleRules
{
    public MyProject(ReadOnlyTargetRules Target) : base(Target)
    {
        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;

        PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
        PublicDependencyModuleNames.AddRange(new string[] { "TestModuleEd"});   // ←ここを追加

        PrivateDependencyModuleNames.AddRange(
            new string[]
            {
                "Slate",
                "SlateCore",
            }
        );
    }
}

using UnrealBuildTool;
using System.Collections.Generic;

public class MyProjectEditorTarget : TargetRules
{
    public MyProjectEditorTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Editor;

        ExtraModuleNames.AddRange( new string[] { "MyProject" } );
        ExtraModuleNames.AddRange( new string[] { "TestModuleEd" } );    // ←ここを追加
    }
}